if (!Array.indexOf) {
    Array.prototype.indexOf = function (obj) {
        for (var i = 0; i < this.length; i++) {
            if (this[i] == obj) {
                return i;
            }
        }
        return -1;
    };
}

/**
 * 删除数组中值为obj的元素，如果有obj元素，则删除第一个obj元素，且返回true, 如果没有，则不删除，且返回false
 */
if(!Array.remove) {
    Array.prototype.remove = function (obj) {
        var index = this.indexOf(obj);
        if(index > -1){
            this.splice(index,1);
            return true;
        } else {
            return false;
        }
    }
}

/**
* 玩的完整的牌是否可以胡，即加上玩家新摸的牌，或者其他玩家打出的牌(总共14张，或者11张，8张，5张，2张)
* @param wholeArray
*/
function isHu(wholeArray){
  var checkArr = new Array();
  checkArr = checkArr.concat(wholeArray);
  //console.log("checkArr.concat:" + checkArr);

  var pairArr = getPairs(checkArr);

  // 获取对牌后，checkArr中的元素已经被全部移除，需要重新放入
  checkArr = checkArr.concat(wholeArray);
  for(var i=0; i< pairArr.length; i++){
      var pair = pairArr[i];
      // 获取对牌的索引，用于删除对牌
      var pairIndex = checkArr.indexOf(pair);
      // 删除对牌：两个元素
      checkArr.splice(pairIndex, 2);

      // 表示只剩下对牌，能胡
      if(checkArr.length == 0){
          return true;
      }else{
          var is7Pair = true;
          // 判断7对，即剩下的12个牌是6对
          if(checkArr.length == 12){
              for(var j=0; j<checkArr.length - 1; j=j+2){
                  var first = checkArr[j];
                  var second = checkArr[j+1];
                  if(first != second){
                      is7Pair = false;
                  }
              }
          }else{  //剩下的牌少于12个牌，不可能是7对
              is7Pair = false;
          }

          if(is7Pair){
              console.log("7 对！");
              return true;
          }

          // 剩下的牌是否都满足AAA或者ABC
          var isHuPai = isAAAorABC(checkArr);
          if(isHuPai){
              return true;
          }else{
              // 重新将checkArr还原，判断下一组对牌做麻将的情况
              checkArr = new Array();
              checkArr = checkArr.concat(wholeArray);
          }
      }
  }

  return false;
}


/**
* 获取对牌
* @param wholeArray
* @returns {Array}
*/
function getPairs(wholeArray){
  var pairArray = new Array();
  for(var i=0; i<wholeArray.length; i++){
      var tmp = wholeArray.shift();
      i--;
      if(wholeArray.indexOf(tmp) > -1){
          if(pairArray.indexOf(tmp) < 0){
              pairArray.push(tmp);
          }
      }
  }

  return pairArray;
}

function sortNumber(a, b) {
    return a - b;
}
/**
* 判断去除对牌(即麻将)之后，是否能够构成AAA或者ABC的牌型
* @param operArray
* @returns {boolean}
*/
function isAAAorABC(array){

  var operArray = new Array();
  operArray = operArray.concat(array);
  operArray.sort(sortNumber); // 必须基于已排序的数组
  var result = false;
  var ELEMENT1;
  var ELEMENT2;
  var ELEMENT3;
  if(operArray.length == 0){
      console.log("已检查完毕，满足AAA或ABC的要求");
      return true;
  }else{
      ELEMENT1 = operArray.shift();   // 获取并移除第一个元素
      ELEMENT2 = operArray.shift();   // 获取并移除第二个元素
      ELEMENT3 = operArray.shift();   // 获取并移除第三个元素
      if(ELEMENT1 == ELEMENT3){     // 已排序的数组，如果ELEMENT1==ELEMENT3，则必然ELEMENT1==ELEMENT2==ELEMENT3; 因此只需要判断一次即可
          console.log("存在 AAA:" + ELEMENT1);
          console.log("剩下需要继续判断的元素："+operArray);
          result = isAAAorABC(operArray);  // 存在AAA，继续递归剩下的元素
      }else{  // 不存在AAA，则判断ABC的情况

          // 还原数组
          operArray = new Array();
          operArray = operArray.concat(array);

          var A = operArray[0];
          var B = A + 1;
          var C = A + 2;

          operArray.remove(A);    // A 肯定存在
          var existB = operArray.remove(B);
          var existC = operArray.remove(C);

          if(existB && existC){ // 表示连续的，即可构成ABC
              console.log("存在ABC：" + ELEMENT1 + "," + ELEMENT2 + "," + ELEMENT3);
              console.log("剩下需要继续判断的元素："+operArray);
              result = isAAAorABC(operArray);
          }else{
              return false;
          }
      }
  }

  return result;
}
export default isHu